-- BP 7.1.6 content: Package syschar: 3 persistence-version: 7.1.6

INSERT INTO EP_PKG
	VALUES ("1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	"c8b88000-dddc-4206-8410-2f69b8f86b67",
	'Process Model Bridges',
	'Incoming bridges for creating model elements of the Process Model subsystem as 
metamodel instances.
',
	0);
INSERT INTO GD_MD
	VALUES ("51c91829-1628-44ea-bb9e-0c0baba1cd25",
	112,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	108,
	0,
	0,
	1,
	1,
	1,
	12,
	1,
	0,
	0,
	0,
	0,
	0,
	'',
	'shlaer-mellor-metamodel::metamodel::Shlaer-Mellor Metamodel::Incoming Bridges::Process Model Bridges');
INSERT INTO DIM_DIA
	VALUES ("51c91829-1628-44ea-bb9e-0c0baba1cd25",
	'',
	1.000000,
	0.000000,
	0.000000,
	"00000000-0000-0000-0000-000000000000");
INSERT INTO S_SYNC
	VALUES ("8bc715f5-6084-4170-94a3-75c6fe98a4d5",
	"00000000-0000-0000-0000-000000000000",
	'addActionToBridge',
	'Adds an empty process model to prepare it for addition of process modeling 
elements.',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any acc from instances of ACC where selected.name == param.bridge_name;
  if (empty acc)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Bridge, " + param.bridge_name + ", not instantiated!" );
  else
    select one brg related by acc->ASA[R505]->ASB[R506]->BRG[R3];
    if (empty brg)
      select one brg related by acc->SYA[R505]->SYB[R524]->BRG[R3];
    end if;
    select one ae related by brg->AE[R509];
    select one act related by ae->ACT[R500];
    if (not empty act)
      result = creationResult_t::DUPLICATE;
      LOG::LogFailure( message:"Action already instantiated for bridge, " + param.bridge_name + "." );
    else
      create object instance act of ACT;
      relate act to ae across R500;
      LOG::LogInfo( message:"Action added to bridge," + param.bridge_name + ", without any processes." );
    end if;
  end if;
end if;
return result;
',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("1ccad135-81f1-4128-9d7c-cce77bbe55c0",
	"8bc715f5-6084-4170-94a3-75c6fe98a4d5",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("dd331316-7410-4277-885a-fd93394bea9a",
	"8bc715f5-6084-4170-94a3-75c6fe98a4d5",
	'bridge_name',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"1ccad135-81f1-4128-9d7c-cce77bbe55c0",
	'The name of the bridge.');
INSERT INTO PE_PE
	VALUES ("8bc715f5-6084-4170-94a3-75c6fe98a4d5",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_DT_PROXY
	VALUES ("709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	"00000000-0000-0000-0000-000000000000",
	'creationResult_t',
	'The creation result type is used in conjunction with creating a Shlaer-Mellor 
domain model to verify it is compatible with the metamodel. The result 
enumerator directs the verifier toward further action.',
	'',
	'../../../DataTypes/DataTypes.xtuml');
INSERT INTO S_SYNC
	VALUES ("be2f9979-73dc-4c4e-9b66-74663ff76d35",
	"00000000-0000-0000-0000-000000000000",
	'addActionToDerivedAttribute',
	'Adds an empty process model to prepare it for addition of process modeling 
elements.',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any der from instances of DER where selected.derived_name == param.attribute;
  if (empty der)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Derived attribute, " + param.attribute + ", not instantiated!" );
  else
    select any atr from instances of ATR where (selected.name == der.value_name) and selected.belongsTo( object:param.object );
    if (empty atr)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"Derived attribute, " + param.attribute + ", not a member of " + param.object + "!");
    else
      select one ae related by der->ATA[R522]->AE[R509];
      select one act related by ae->ACT[R500];
      if (not empty act)
        result = creationResult_t::DUPLICATE;
        LOG::LogFailure( message:"Action already instantiated for derived attribute, " + param.attribute + "." );
      else
        create object instance act of ACT;
        relate act to ae across R500;
        LOG::LogInfo( message:"Action added to derived attribute," + param.attribute + ", without any processes." );
      end if;
    end if;
  end if;
end if;
return result;',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("ccac2027-cc9a-4658-a318-3f4eaa6b7052",
	"be2f9979-73dc-4c4e-9b66-74663ff76d35",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("af413621-f2d0-4e70-8177-fb5041068398",
	"be2f9979-73dc-4c4e-9b66-74663ff76d35",
	'object',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"ccac2027-cc9a-4658-a318-3f4eaa6b7052",
	'The name of the object that has behavior specified by the state model.');
INSERT INTO S_SPARM
	VALUES ("daddf128-613f-4c60-9b7a-0df8f9cd2237",
	"be2f9979-73dc-4c4e-9b66-74663ff76d35",
	'attribute',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"af413621-f2d0-4e70-8177-fb5041068398",
	'The name of the derived attribute.');
INSERT INTO PE_PE
	VALUES ("be2f9979-73dc-4c4e-9b66-74663ff76d35",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("4d8f04ab-0a27-4f4a-9fdf-662c92533684",
	"00000000-0000-0000-0000-000000000000",
	'addActionToMethod',
	'Adds an empty process model to prepare it for addition of process modeling 
elements.
',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any mth from instances of MTH where selected.name == param.method;
  if (empty mth)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Method, " + param.method + ", not instantiated!" );
  else
    select one ae related by mth->AE[R509];
    select one act related by ae->ACT[R500];
    if (not empty act)
      result = creationResult_t::DUPLICATE;
      LOG::LogFailure( message:"Action already instantiated for method, " + param.method + "." );
    else
      create object instance act of ACT;
      relate act to ae across R500;
      LOG::LogInfo( message:"Action added to method," + param.method + ", without any processes." );
    end if;
  end if;
end if;
return result;',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("c894f394-0c8f-4894-8208-b283f57efca8",
	"4d8f04ab-0a27-4f4a-9fdf-662c92533684",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("87279969-e1d9-417b-af1d-1b4738e341b4",
	"4d8f04ab-0a27-4f4a-9fdf-662c92533684",
	'object',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"c894f394-0c8f-4894-8208-b283f57efca8",
	'The name of the object that has behavior specified by the state model.');
INSERT INTO S_SPARM
	VALUES ("933ae39d-9c10-4ce3-a75c-c296464ba47a",
	"4d8f04ab-0a27-4f4a-9fdf-662c92533684",
	'method',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"87279969-e1d9-417b-af1d-1b4738e341b4",
	'The name of the method.');
INSERT INTO PE_PE
	VALUES ("4d8f04ab-0a27-4f4a-9fdf-662c92533684",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("26bfc877-1758-48a0-9fac-a4d4f3c3ce71",
	"00000000-0000-0000-0000-000000000000",
	'addActionToState',
	'Adds an empty process model to prepare it for addition of process modeling 
elements.

',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any sub from instances of SUB where selected.name == param.object;
  if (empty sub)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
  else
    select any sta related by sub->LIF[R347]->SM[R300]->STA[R341] where selected.name == param.state;
    if (empty sta)
      select any sta related by sub->ASR[R354]->SM[R300]->STA[R341] where selected.name == param.state;
      if (empty sta)
        result = creationResult_t::FAILURE;
        LOG::LogFailure( message:"State, " + param.state + ", not instantiated!" );
      end if;
    end if;
    if ( creationResult_t::SUCCESS == result )
      select one ae related by sta->AE[R509];
      select one act related by ae->ACT[R500];
      if (not empty act)
        result = creationResult_t::DUPLICATE;
        LOG::LogFailure( message:"Action already instantiated for state, " + param.state + "." );
      else
        create object instance act of ACT;
        relate ae to act across R500;
        LOG::LogInfo( message:"Action added to state," + param.state + ", without any processes." );
      end if;
    end if;
  end if;
end if;
return result;',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("b990a67a-2bd8-4ec8-837d-c1d5b5ffbc29",
	"26bfc877-1758-48a0-9fac-a4d4f3c3ce71",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("701940e9-83d7-43a2-881a-0c9d7733b908",
	"26bfc877-1758-48a0-9fac-a4d4f3c3ce71",
	'object',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"b990a67a-2bd8-4ec8-837d-c1d5b5ffbc29",
	'The name of the object that has behavior specified by the state model.');
INSERT INTO S_SPARM
	VALUES ("c54ee91f-cadc-4e9a-83cf-5b1afef4e4c2",
	"26bfc877-1758-48a0-9fac-a4d4f3c3ce71",
	'state',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"701940e9-83d7-43a2-881a-0c9d7733b908",
	'The name of the state.');
INSERT INTO PE_PE
	VALUES ("26bfc877-1758-48a0-9fac-a4d4f3c3ce71",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("bcb2a490-3b3c-4c30-bb98-8f8beb031626",
	"00000000-0000-0000-0000-000000000000",
	'addAttributeToOperand',
	'Add an attribute of an object instance, already added to the process model, to 
the left-hand or right-hand operand of the specified expression.',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
    if (empty pro)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
    else
      select any equ related by pro->RE[R502]->EQU[R514];
      if (empty equ)
        result = creationResult_t::FAILURE;
        LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
      else
        select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
        if (empty exp)
          result = creationResult_t::FAILURE;
          LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
        else
          select any sub from instances of SUB where selected.name == param.object;
          if (empty sub)
            result = creationResult_t::FAILURE;
            LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
          else
            select any atr related by sub->OBJ[R107]->OA[R129]->ATR[R124] where selected.name == param.attribute;
            if (empty atr)
              select any atr related by sub->PRP[R107]->SPA[R130]->ATR[R124] where selected.name == param.attribute;
            end if;
            if (empty atr)
              result = creationResult_t::FAILURE;
              LOG::LogFailure( message:"Attribute, " + param.attribute + ", not instantiated!" );
            else
              // An object instance must exist to access the attribute instance.
              select any trd related by pro->RE[R502]->EQU[R514]->EXP[R622]->LHO[R616]->OPRD[R615]->DUS[R631]->VAR[R624]->TRD[R626] where selected.name == param.instance;
              if (empty trd)
                result = creationResult_t::FAILURE;
                LOG::LogFailure( message:"Unable to find object instance handle in this process model!" );
              else
                select any atn related by trd->VAR[R626]->VAL[R635]->INS[R629]->ATN[R643] where selected.attribute_name == param.attribute;
                select one dus related by atn->VAR[R626]->DUS[R624];
                select one oprd related by exp->LHO[R616]->OPRD[R615];
                if (empty oprd)
                  result = creationResult_t::FAILURE;
                  LOG::LogFailure( message:"Left hand operand not instantiated!" );
                else
                  if (not param.leftHand)
                    select one oprd related by exp->RHO[R617]->OPRD[R615];
                    if (empty oprd)
                      result = creationResult_t::FAILURE;
                      LOG::LogFailure( message:"Right hand operand not instantiated!" );
                    end if;
                  end if;
                  if (not empty oprd)
                    relate oprd to dus across R631;
                  end if;
                end if;
              end if;
            end if;
          end if;
        end if;
      end if;
    end if;
  end if;
end if;
return result;

',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("7fb16af2-3414-487f-b20a-6e6745acfe01",
	"bcb2a490-3b3c-4c30-bb98-8f8beb031626",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("2d13a645-8446-4706-b6b8-bebff59030b0",
	"bcb2a490-3b3c-4c30-bb98-8f8beb031626",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"7fb16af2-3414-487f-b20a-6e6745acfe01",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("9dc07aee-20fc-430c-9e5d-11b74b584c7c",
	"bcb2a490-3b3c-4c30-bb98-8f8beb031626",
	'processPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"2d13a645-8446-4706-b6b8-bebff59030b0",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("d5421344-5705-460b-a75f-b26bbe7a69bf",
	"bcb2a490-3b3c-4c30-bb98-8f8beb031626",
	'expressionPosition',
	"ba5eda7a-def5-0000-0000-000000000002",
	0,
	'',
	"9dc07aee-20fc-430c-9e5d-11b74b584c7c",
	'The ordinal position of the expression in the equation. This needs to be 
maintained by the external editor.
    This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...
    See the description of expression and R622 for further explanation of 
ordering in adding expressions to the equation.');
INSERT INTO S_SPARM
	VALUES ("f4c52f28-2abe-48f0-9ac0-b9510d70910b",
	"bcb2a490-3b3c-4c30-bb98-8f8beb031626",
	'object',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"9c064d1b-b0d2-4d2e-8ca4-a908dd7d1819",
	'The name of the object.');
INSERT INTO S_SPARM
	VALUES ("86daba16-7474-42aa-acd3-551d6cc7564f",
	"bcb2a490-3b3c-4c30-bb98-8f8beb031626",
	'attribute',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"f4c52f28-2abe-48f0-9ac0-b9510d70910b",
	'The name of the attribute.');
INSERT INTO S_SPARM
	VALUES ("9c064d1b-b0d2-4d2e-8ca4-a908dd7d1819",
	"bcb2a490-3b3c-4c30-bb98-8f8beb031626",
	'leftHand',
	"ba5eda7a-def5-0000-0000-000000000001",
	0,
	'',
	"d5421344-5705-460b-a75f-b26bbe7a69bf",
	'Indicator of adding to the left-hand or right-hand operand. A value of true 
means add to the left-hand operand.');
INSERT INTO S_SPARM
	VALUES ("5370d2e4-741c-4aaf-80a4-8e6bd6af87c6",
	"bcb2a490-3b3c-4c30-bb98-8f8beb031626",
	'instance',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"86daba16-7474-42aa-acd3-551d6cc7564f",
	'The name of the object instance variable used to access the attribute instance.');
INSERT INTO PE_PE
	VALUES ("bcb2a490-3b3c-4c30-bb98-8f8beb031626",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("59c03d25-2758-48a2-a65b-43a34d984cce",
	"00000000-0000-0000-0000-000000000000",
	'addEquationToProcess',
	'Add an equation without expressions to the process specified within the action 
specified.',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    select any pro related by act->PRO[R501] where selected.ordinal_position == param.ordinalPosition;
    if (empty pro)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.ordinalPosition ) + "!");
    else
      create object instance re of RE;
      create object instance ela of ELA;
      relate re to pro across R502 using ela;
      create object instance equ of EQU;
      relate equ to re across R514;
      LOG::LogInfo( message: "Equation added to action without any expressions!" );
    end if;
  end if;
end if;
return result;

',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("64188e21-67a3-417d-bded-8bda41f410e6",
	"59c03d25-2758-48a2-a65b-43a34d984cce",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("688df74b-cf38-4dad-87e2-e12b66b8de36",
	"59c03d25-2758-48a2-a65b-43a34d984cce",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"64188e21-67a3-417d-bded-8bda41f410e6",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("535edc5c-6267-4355-8f01-4f24cc479481",
	"59c03d25-2758-48a2-a65b-43a34d984cce",
	'ordinalPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"688df74b-cf38-4dad-87e2-e12b66b8de36",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO PE_PE
	VALUES ("59c03d25-2758-48a2-a65b-43a34d984cce",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("43e71252-166d-463d-9709-d7f5b016634f",
	"00000000-0000-0000-0000-000000000000",
	'addExpressionToEquation',
	'Add an expression, without operands, operation, or outcome, at the position 
specified to the equation of the process specified in the action specified.',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
    if (empty pro)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
    else
      select any equ related by pro->RE[R502]->EQU[R514];
      if (empty equ)
        result = creationResult_t::FAILURE;
        LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
      else
        create object instance exp of EXP;
        exp.ordinal_position = param.ordinalPosition;
        relate exp to equ across R622;
        LOG::LogInfo( message: "Expression added to equation without any operands!" );
      end if;
    end if;
  end if;
end if;
return result;

',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("024cc3cf-b3b1-42fe-8406-ff93ca77fb14",
	"43e71252-166d-463d-9709-d7f5b016634f",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("7ca07885-7a4d-4c32-92a5-fa4c1aa80787",
	"43e71252-166d-463d-9709-d7f5b016634f",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"024cc3cf-b3b1-42fe-8406-ff93ca77fb14",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("e9f7a202-20a8-44cd-b72f-effaaf9f55a6",
	"43e71252-166d-463d-9709-d7f5b016634f",
	'processPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"7ca07885-7a4d-4c32-92a5-fa4c1aa80787",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("d96b35a4-d1be-431f-8ccf-1c4412f775fd",
	"43e71252-166d-463d-9709-d7f5b016634f",
	'ordinalPosition',
	"ba5eda7a-def5-0000-0000-000000000002",
	0,
	'',
	"e9f7a202-20a8-44cd-b72f-effaaf9f55a6",
	'The ordinal position of the expression in the equation. This needs to be 
maintained by the external editor.
    This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...
    See the description of expression and R622 for further explanation of 
ordering in adding expressions to the equation.');
INSERT INTO PE_PE
	VALUES ("43e71252-166d-463d-9709-d7f5b016634f",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("44d634a6-cfe9-4917-9093-18a389732efe",
	"00000000-0000-0000-0000-000000000000",
	'addIterationToAction',
	'Add an iteration process to the specified action at the specified ordinal 
position.',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    create object instance pro of PRO;
    pro.ordinal_position = param.ordinalPosition;
    relate pro to act across R501;
    create object instance csp of CSP;
    csp.closure_position = param.closurePosition;
    relate csp to pro across R536;
    create object instance itp of ITP;
    itp.current_index = 1;
    relate itp to csp across R537;
  end if;
end if;
return result;

',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("0e0b97c5-a0ea-468b-9e48-8a65f753d03a",
	"44d634a6-cfe9-4917-9093-18a389732efe",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("30595595-bfdc-43cd-ad4e-87482a382bc2",
	"44d634a6-cfe9-4917-9093-18a389732efe",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"0e0b97c5-a0ea-468b-9e48-8a65f753d03a",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("2cff5a95-ed7e-4c25-b81e-16431b81825d",
	"44d634a6-cfe9-4917-9093-18a389732efe",
	'ordinalPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"30595595-bfdc-43cd-ad4e-87482a382bc2",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("b40e5798-de42-4b83-96ba-2a3edc3b04cc",
	"44d634a6-cfe9-4917-9093-18a389732efe",
	'closurePosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"2cff5a95-ed7e-4c25-b81e-16431b81825d",
	'The ordinal position of the end of the control structure.
NOTE: As the editor is responsible for assigning ordinal positions, this will 
always be a known parameter. Other bridges will provide for maintenance of the 
model. i.e., insertion and deletion of lines.');
INSERT INTO PE_PE
	VALUES ("44d634a6-cfe9-4917-9093-18a389732efe",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("41476afc-677d-4be9-bfb6-ef134a1ec1ca",
	"00000000-0000-0000-0000-000000000000",
	'addLoopToAction',
	'Add a loop process to the specified action at the specified ordinal position.',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    create object instance pro of PRO;
    pro.ordinal_position = param.ordinalPosition;
    relate pro to act across R501;
    create object instance csp of CSP;
    csp.closure_position = param.closurePosition;
    relate csp to pro across R536;
    create object instance lop of LOP;
    relate lop to csp across R537;
  end if;
end if;
return result;

',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("4faa443e-e635-4f65-a769-16f222e05b29",
	"41476afc-677d-4be9-bfb6-ef134a1ec1ca",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("9662ab8f-fece-471c-a2f5-04f2175edd6f",
	"41476afc-677d-4be9-bfb6-ef134a1ec1ca",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"4faa443e-e635-4f65-a769-16f222e05b29",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("3e17916d-0c71-4cd2-b4ca-dbe1838b48be",
	"41476afc-677d-4be9-bfb6-ef134a1ec1ca",
	'ordinalPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"9662ab8f-fece-471c-a2f5-04f2175edd6f",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("8964f42d-dae2-4057-94f9-5f66bb9d0da0",
	"41476afc-677d-4be9-bfb6-ef134a1ec1ca",
	'closurePosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"3e17916d-0c71-4cd2-b4ca-dbe1838b48be",
	'The ordinal position of the end of the control structure.
NOTE: As the editor is responsible for assigning ordinal positions, this will 
always be a known parameter. Other bridges will provide for maintenance of the 
model. i.e., insertion and deletion of lines.');
INSERT INTO PE_PE
	VALUES ("41476afc-677d-4be9-bfb6-ef134a1ec1ca",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("3c0c2b66-0e73-4215-9dc0-29e4ff924e33",
	"00000000-0000-0000-0000-000000000000",
	'addObjectInstanceToOperand',
	'Add an object to the right-hand operand of the specified expression as an 
instance. The only valid use of this is when you are creating an object 
instance for assignment to a variable for later use in the process model, which 
is why it is always the right-hand operand.',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
    if (empty pro)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
    else
      select any equ related by pro->RE[R502]->EQU[R514];
      if (empty equ)
        result = creationResult_t::FAILURE;
        LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
      else
        select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
        if (empty exp)
          result = creationResult_t::FAILURE;
          LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
        else
          select one rho related by exp->RHO[R617];
          if (empty rho)
            result = creationResult_t::FAILURE;
            LOG::LogFailure( message:"Right-hand operand not instantiated!" );
          else
            select any sub from instances of SUB where selected.name == param.object;
            if (empty sub)
              result = creationResult_t::FAILURE;
              LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
            else
              create object instance ins of INS;
              relate ins to sub across R112;
              // Create all attribute instances
              sub.instantiateAttributes(objectInstance:ins.id);
              // Create all method instances
              sub.instantiateMethods(objectInstance:ins.id);
              // Create state machine
              select one lif related by sub->LIF[R347];
              if (not empty lif)
                create object instance lsm of LSM;
                relate lsm to ins across R361;
             relate lsm to lif across R360;
                select any cre related by lif->SM[R300]->STA[R341]->LIV[R305]->CRE[R306];
                relate cre to lsm across R348;
                select any del related by lif->SM[R300]->STA[R341]->DEL[R305];
                if (not empty del)
                  create object instance des of DES;
                  relate del to lsm across R349 using des;
                end if;
              end if;
              // Find the identifiers for the instance and relate them to the instance.
              select one prp related by sub->PRP[R107];
              if (not empty prp)
                select many ids related by sub->PRP[R107]->SPA[R130]->ATR[R124]->ID[R102];
                for each id in ids
                  create object instance itn of ITN;
                  relate ins to id across R101 using itn;
                end for;
              else
                select many ids related by sub->OBJ[R107]->OA[R129]->ATR[R124]->ID[R102];
                for each id in ids
                  create object instance itn of ITN;
                  relate ins to id across R101 using itn;
                end for;
              end if;
              // Setup instance as a value in the system.
              select any iref from instances of IREF;
              relate ins to iref across R417;
              create object instance val of VAL;
              relate val to ins across R629;
              create object instance dus of DUS;
              relate dus to val across R624;
              select one type related by iref->CORE[R403]->TYPE[R401];
              relate dus to type across R625;
              // Add data to operand
              create object instance re of RE;
              relate dus to re across R514;
              create object instance ela of ELA;
              relate re to pro across R502 using ela;
              select one oprd related by rho->OPRD[R615];
              relate oprd to dus across R631;
            end if;
          end if;
        end if;
      end if;
    end if;
  end if;
end if;
return result;

',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("b75a216e-b099-454c-b462-48b86e6da2cd",
	"3c0c2b66-0e73-4215-9dc0-29e4ff924e33",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("f9735b01-6331-4164-a492-a80c8e585e62",
	"3c0c2b66-0e73-4215-9dc0-29e4ff924e33",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"b75a216e-b099-454c-b462-48b86e6da2cd",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("76a0c380-d771-4d6c-b01b-58ccf9538a75",
	"3c0c2b66-0e73-4215-9dc0-29e4ff924e33",
	'processPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"f9735b01-6331-4164-a492-a80c8e585e62",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("4afbcfd8-d52b-4b46-952f-d7334a465e51",
	"3c0c2b66-0e73-4215-9dc0-29e4ff924e33",
	'expressionPosition',
	"ba5eda7a-def5-0000-0000-000000000002",
	0,
	'',
	"76a0c380-d771-4d6c-b01b-58ccf9538a75",
	'The ordinal position of the expression in the equation. This needs to be 
maintained by the external editor.
    This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...
    See the description of expression and R622 for further explanation of 
ordering in adding expressions to the equation.');
INSERT INTO S_SPARM
	VALUES ("9ae0ffa3-d45b-4b6a-8c66-8a7114d51210",
	"3c0c2b66-0e73-4215-9dc0-29e4ff924e33",
	'object',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"4afbcfd8-d52b-4b46-952f-d7334a465e51",
	'The name of the object.');
INSERT INTO PE_PE
	VALUES ("3c0c2b66-0e73-4215-9dc0-29e4ff924e33",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("c5f01d57-0466-48fd-8589-7c5e94df8708",
	"00000000-0000-0000-0000-000000000000",
	'addOperandToExpression',
	'Add a left-hand or right-hand operand to the expression. The order of addition 
to the expression is left-hand operand, right-hand operand, and then operator, 
and this is strictly enforced.',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
    if (empty pro)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
    else
      select any equ related by pro->RE[R502]->EQU[R514];
      if (empty equ)
        result = creationResult_t::FAILURE;
        LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
      else
        select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
        if (empty exp)
          result = creationResult_t::FAILURE;
          LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
        else
          select one lho related by exp->LHO[R616];
          if (param.leftHand)
            if (not empty lho)
              result = creationResult_t::DUPLICATE;
              LOG::LogFailure( message:"Left hand operand already created for this expression!" );
            else
              create object instance oprd of OPRD;
              create object instance lho of LHO;
              relate lho to oprd across R615;
              relate lho to exp across R616;
              LOG::LogInfo( message:"Left operand created without any data assignment!" );
            end if;
          else
            if (empty lho)
              result = creationResult_t::FAILURE;
              LOG::LogFailure( message:"Left hand operand must be created before right hand operand!" );
            else
              select one rho related by exp->RHO[R617];
              if (not empty rho)
                result = creationResult_t::DUPLICATE;
                LOG::LogFailure( message:"Right hand operand already created for this expression!" );
              else
                create object instance oprd of OPRD;
                create object instance rho of RHO;
                relate rho to oprd across R615;
                relate rho to exp across R617;
                LOG::LogInfo( message:"Right operand created without any data assignment!" );
              end if;
            end if;
          end if;
        end if;
      end if;
    end if;
  end if;
end if;
return result;
',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("f8e18b63-034b-4562-ba42-b8772211ef1e",
	"c5f01d57-0466-48fd-8589-7c5e94df8708",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("a0f25968-bbe8-4daf-9386-ee7fe8004551",
	"c5f01d57-0466-48fd-8589-7c5e94df8708",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"f8e18b63-034b-4562-ba42-b8772211ef1e",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("3d48a23f-a319-493b-8b90-2de3db60bc2b",
	"c5f01d57-0466-48fd-8589-7c5e94df8708",
	'processPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"a0f25968-bbe8-4daf-9386-ee7fe8004551",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("d113345a-750f-4c3f-be01-50604a270df8",
	"c5f01d57-0466-48fd-8589-7c5e94df8708",
	'expressionPosition',
	"ba5eda7a-def5-0000-0000-000000000002",
	0,
	'',
	"3d48a23f-a319-493b-8b90-2de3db60bc2b",
	'The ordinal position of the expression in the equation. This needs to be 
maintained by the external editor.
    This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...
    See the description of expression and R622 for further explanation of 
ordering in adding expressions to the equation.');
INSERT INTO S_SPARM
	VALUES ("410b131d-bdd6-40b9-b3bc-6e5ed8974142",
	"c5f01d57-0466-48fd-8589-7c5e94df8708",
	'leftHand',
	"ba5eda7a-def5-0000-0000-000000000001",
	0,
	'',
	"d113345a-750f-4c3f-be01-50604a270df8",
	'Indicator of adding the left-hand or right-hand operand. A value of true means 
add the left-hand operand.');
INSERT INTO PE_PE
	VALUES ("c5f01d57-0466-48fd-8589-7c5e94df8708",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("ef0e6484-2877-42b3-8585-dec5c7bf6b12",
	"00000000-0000-0000-0000-000000000000",
	'addPathEvaluationToAction',
	'Add a path evaluation process to the specified action at the specified ordinal 
position. This creates the path evaluation specifier and opens the first path 
container.',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    create object instance pro of PRO;
    pro.ordinal_position = param.ordinalPosition;
    relate pro to act across R501;
    create object instance csp of CSP;
    csp.closure_position = param.closurePosition;
    relate csp to pro across R536;
    create object instance pep of PEP;
    pep.numPaths = 1;
    relate pep to csp across R537;
  end if;
end if;
return result;
',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("00041a8d-1a70-4937-bcb8-2cada5ebf45c",
	"ef0e6484-2877-42b3-8585-dec5c7bf6b12",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("dc886a7a-9968-49f0-a279-a946d8ecfd88",
	"ef0e6484-2877-42b3-8585-dec5c7bf6b12",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"00041a8d-1a70-4937-bcb8-2cada5ebf45c",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("00ecda73-ec8e-46dd-83bf-fd5e05352efb",
	"ef0e6484-2877-42b3-8585-dec5c7bf6b12",
	'ordinalPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"dc886a7a-9968-49f0-a279-a946d8ecfd88",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("1e400b6f-208a-406b-b4a0-e15bec42317a",
	"ef0e6484-2877-42b3-8585-dec5c7bf6b12",
	'closurePosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"00ecda73-ec8e-46dd-83bf-fd5e05352efb",
	'The ordinal position of the end of the control structure.
NOTE: As the editor is responsible for assigning ordinal positions, this will 
always be a known parameter. Other bridges will provide for maintenance of the 
model. i.e., insertion and deletion of lines.');
INSERT INTO PE_PE
	VALUES ("ef0e6484-2877-42b3-8585-dec5c7bf6b12",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("52ff3441-8152-47ab-a81e-9b85fb0642f1",
	"00000000-0000-0000-0000-000000000000",
	'addReferentialAttributeToOperand',
	'Add a referential attribute of an object instance, already added to the process 
model, to the left-hand or right-hand operand of the specified expression.
',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
    if (empty pro)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
    else
      select any equ related by pro->RE[R502]->EQU[R514];
      if (empty equ)
        result = creationResult_t::FAILURE;
        LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
      else
        select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
        if (empty exp)
          result = creationResult_t::FAILURE;
          LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
        else
          select any sub from instances of SUB where selected.name == param.object;
          if (empty sub)
            result = creationResult_t::FAILURE;
            LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
          else
            select any ref related by sub->OBJ[R107]->OA[R129]->ATR[R124]->REF[R103] where selected.name == param.attribute;
            if (empty ref)
              select any ref related by sub->PRP[R107]->SPA[R130]->ATR[R124]->REF[R103] where selected.name == param.attribute;
            end if;
            if (empty ref)
              result = creationResult_t::FAILURE;
              LOG::LogFailure( message:"Referential attribute, " + param.attribute + ", not instantiated!" );
            else
              // An object instance must exist to access the attribute instance.
              select any trd related by pro->RE[R502]->EQU[R514]->EXP[R622]->LHO[R616]->OPRD[R615]->DUS[R631]->VAR[R624]->TRD[R626] where selected.name == param.instance;
              if (empty trd)
                result = creationResult_t::FAILURE;
                LOG::LogFailure( message:"Unable to find object instance handle in this process model!" );
              else
                select any atn related by trd->VAR[R626]->VAL[R635]->INS[R629]->ATN[R643] where selected.attribute_name == param.attribute;
                select one dus related by atn->VAR[R626]->DUS[R624];
                select one oprd related by exp->LHO[R616]->OPRD[R615];
                if (empty oprd)
                  result = creationResult_t::FAILURE;
                  LOG::LogFailure( message:"Left hand operand not instantiated!" );
                else
                  if (not param.leftHand)
                    select one oprd related by exp->RHO[R617]->OPRD[R615];
                    if (empty oprd)
                      result = creationResult_t::FAILURE;
                      LOG::LogFailure( message:"Right hand operand not instantiated!" );
                    end if;
                  end if;
                  if (not empty oprd)
                    relate oprd to dus across R631;
                  end if;
                end if;
              end if;
            end if;
          end if;
        end if;
      end if;
    end if;
  end if;
end if;
return result;

',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("4aa8795c-9586-4c01-a408-63e9e2101815",
	"52ff3441-8152-47ab-a81e-9b85fb0642f1",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("ec9e01ed-a1be-4340-b1da-4378791b8925",
	"52ff3441-8152-47ab-a81e-9b85fb0642f1",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"4aa8795c-9586-4c01-a408-63e9e2101815",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("9de271d2-4a5f-4284-8ddc-fc2d0d6cbd7a",
	"52ff3441-8152-47ab-a81e-9b85fb0642f1",
	'processPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"ec9e01ed-a1be-4340-b1da-4378791b8925",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("f5a07d2e-65d3-49c1-82ae-c6c675241120",
	"52ff3441-8152-47ab-a81e-9b85fb0642f1",
	'expressionPosition',
	"ba5eda7a-def5-0000-0000-000000000002",
	0,
	'',
	"9de271d2-4a5f-4284-8ddc-fc2d0d6cbd7a",
	'The ordinal position of the expression in the equation. This needs to be 
maintained by the external editor.
    This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...
    See the description of expression and R622 for further explanation of 
ordering in adding expressions to the equation.');
INSERT INTO S_SPARM
	VALUES ("f3fd6a41-72e6-430a-ac43-3f98d2ef66e4",
	"52ff3441-8152-47ab-a81e-9b85fb0642f1",
	'leftHand',
	"ba5eda7a-def5-0000-0000-000000000001",
	0,
	'',
	"f5a07d2e-65d3-49c1-82ae-c6c675241120",
	'Indicator of adding to the left-hand or right-hand operand. A value of true 
means add to the left-hand operand.');
INSERT INTO S_SPARM
	VALUES ("7cdada6a-6afa-4c3b-86bd-8ae0509ab025",
	"52ff3441-8152-47ab-a81e-9b85fb0642f1",
	'object',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"f3fd6a41-72e6-430a-ac43-3f98d2ef66e4",
	'The name of the object.');
INSERT INTO S_SPARM
	VALUES ("8b921733-a79e-4b5c-adeb-51efec8ee6e7",
	"52ff3441-8152-47ab-a81e-9b85fb0642f1",
	'attribute',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"7cdada6a-6afa-4c3b-86bd-8ae0509ab025",
	'The name of the attribute.');
INSERT INTO S_SPARM
	VALUES ("1c104784-5a1d-4089-8ac4-5ca3df5e71d6",
	"52ff3441-8152-47ab-a81e-9b85fb0642f1",
	'instance',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"8b921733-a79e-4b5c-adeb-51efec8ee6e7",
	'The name of the object instance variable used to access the attribute instance.');
INSERT INTO PE_PE
	VALUES ("52ff3441-8152-47ab-a81e-9b85fb0642f1",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("c2460a6a-de3c-413b-95ad-8307252ce716",
	"00000000-0000-0000-0000-000000000000",
	'addStatementToAction',
	'Add a Statement Process to the specified action at the specified ordinal 
position.',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    create object instance pro of PRO;
    pro.ordinal_position = param.ordinalPosition;
    relate pro to act across R501;
    create object instance stp of STP;
    relate stp to pro across R536;
    // Determine if container relationships need to be instantiated.
    closest = 0.0;
    select many csps from instances of CSP where ( selected.ordinal_position < param.ordinalPosition ) and ( selected.closure_position >= param.ordinalPosition );
    for each csp in csps
      // Position numbering is one-based, and the statement can''t be added at 
      // the control structure position.
      if (csp.ordinal_position > closest)
        closest = csp.ordinal_position;
      end if;
    end for;
    select any csp from instances of CSP where selected.ordinal_position == closest;
    if (not empty csp)
      create object instance pns of PNS;
      relate csp to pro across R538 using pns;
      select one pep related by csp->PEP[R537];
      if (not empty pep)
        create object instance pas of PAS;
        relate pep to pns across R539 using pas;
      end if;
    end if;
  end if;
end if;
return result;
',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("6bbe07b4-a472-4d42-92cd-1f2a4b4c5c97",
	"c2460a6a-de3c-413b-95ad-8307252ce716",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("524cc091-602f-43a9-85a9-d364d1e29a54",
	"c2460a6a-de3c-413b-95ad-8307252ce716",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"6bbe07b4-a472-4d42-92cd-1f2a4b4c5c97",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.');
INSERT INTO S_SPARM
	VALUES ("0a27f83c-655c-421e-832a-84ed0f926f5a",
	"c2460a6a-de3c-413b-95ad-8307252ce716",
	'ordinalPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"524cc091-602f-43a9-85a9-d364d1e29a54",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO PE_PE
	VALUES ("c2460a6a-de3c-413b-95ad-8307252ce716",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("716d688a-c45e-4d24-8252-80ab15ef9f2f",
	"00000000-0000-0000-0000-000000000000",
	'getActionOfBridge',
	'Returns the identifier of the action instance associated with the specified 
element. Will return an invalid identifier if the model isn''t correct for this 
action.',
	'// Start with an invalid id.
// TODO: Verify this works
select any act from instances of ACT where selected.id != selected.id;
id = act.id;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any acc from instances of ACC where selected.name == param.bridge_name;
  if (empty acc)
    LOG::LogFailure( message:"Bridge, " + param.bridge_name + ", not instantiated!" );
  else
    select one brg related by acc->ASA[R505]->ASB[R506]->BRG[R3];
    if (empty brg)
      select one brg related by acc->SYA[R505]->SYB[R524]->BRG[R3];
    end if;
    select one ae related by brg->AE[R509];
    select one act related by ae->ACT[R500];
    if (empty act)
      LOG::LogFailure( message:"Action not instantiated for bridge, " + param.bridge_name + "." );
    else
      id = act.id;
    end if;
  end if;
end if;
return id;',
	"ba5eda7a-def5-0000-0000-000000000005",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("a2704386-330f-495a-909f-d0b8fff60467",
	"716d688a-c45e-4d24-8252-80ab15ef9f2f",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("99e17643-2c88-445c-b41d-a381f71229ec",
	"716d688a-c45e-4d24-8252-80ab15ef9f2f",
	'bridge_name',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"a2704386-330f-495a-909f-d0b8fff60467",
	'The name of the bridge.');
INSERT INTO PE_PE
	VALUES ("716d688a-c45e-4d24-8252-80ab15ef9f2f",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("7441c8c5-3fb2-406c-abcc-8cdc6bb33342",
	"00000000-0000-0000-0000-000000000000",
	'getActionOfDerivedAttribute',
	'Returns the identifier of the action instance associated with the specified 
element. Will return an invalid identifier if the model isn''t correct for this 
action.',
	'// Start with an invalid id.
select any act from instances of ACT where selected.id != selected.id;
id = act.id;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any der from instances of DER where selected.derived_name == param.attribute;
  if (empty der)
    LOG::LogFailure( message:"Derived attribute, " + param.attribute + ", not instantiated!" );
  else
    select any atr from instances of ATR where (selected.name == der.value_name) and selected.belongsTo( object:param.object );
    if (empty atr)
      LOG::LogFailure( message:"Derived attribute, " + param.attribute + ", not a member of " + param.object + "!");
    else
      select one ae related by der->ATA[R522]->AE[R509];
      select one act related by ae->ACT[R500];
      if (empty act)
        LOG::LogFailure( message:"Action not instantiated for derived attribute, " + param.attribute + "." );
      else
        id = act.id;
      end if;
    end if;
  end if;
end if;
return id;

',
	"ba5eda7a-def5-0000-0000-000000000005",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("229d3218-934f-4a87-be9f-20432c8f1481",
	"7441c8c5-3fb2-406c-abcc-8cdc6bb33342",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("93a2aff4-8088-454f-b4cd-462f64e26370",
	"7441c8c5-3fb2-406c-abcc-8cdc6bb33342",
	'object',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"229d3218-934f-4a87-be9f-20432c8f1481",
	'The name of the object that has behavior specified by the state model.');
INSERT INTO S_SPARM
	VALUES ("a77a7d20-c9eb-4973-b0b3-4f5c0026452c",
	"7441c8c5-3fb2-406c-abcc-8cdc6bb33342",
	'attribute',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"93a2aff4-8088-454f-b4cd-462f64e26370",
	'The name of the derived attribute.');
INSERT INTO PE_PE
	VALUES ("7441c8c5-3fb2-406c-abcc-8cdc6bb33342",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("3397543b-371b-4b76-a86a-1539f6987278",
	"00000000-0000-0000-0000-000000000000",
	'getActionOfMethod',
	'Returns the identifier of the action instance associated with the specified 
element. Will return an invalid identifier if the model isn''t correct for this 
action.',
	'// Start with an invalid id.
select any act from instances of ACT where selected.id != selected.id;
id = act.id;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any mth from instances of MTH where selected.name == param.method;
  if (empty mth)
    LOG::LogFailure( message:"Method, " + param.method + ", not instantiated!" );
  else
    select one ae related by mth->AE[R509];
    select one act related by ae->ACT[R500];
    if (empty act)
      LOG::LogFailure( message:"Action not instantiated for method, " + param.method + "." );
    else
      id = act.id;
    end if;
  end if;
end if;
return id;

',
	"ba5eda7a-def5-0000-0000-000000000005",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("b175399b-4734-4db3-92a2-80905b8cd0f8",
	"3397543b-371b-4b76-a86a-1539f6987278",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("2dd79aec-b2eb-46ef-b81b-4ee6485b2e96",
	"3397543b-371b-4b76-a86a-1539f6987278",
	'object',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"b175399b-4734-4db3-92a2-80905b8cd0f8",
	'The name of the object that has behavior specified by the state model.');
INSERT INTO S_SPARM
	VALUES ("02a43970-0bb5-492e-bdf5-2936854d0492",
	"3397543b-371b-4b76-a86a-1539f6987278",
	'method',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"2dd79aec-b2eb-46ef-b81b-4ee6485b2e96",
	'The name of the method.');
INSERT INTO PE_PE
	VALUES ("3397543b-371b-4b76-a86a-1539f6987278",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("659d77cb-9830-41e1-810d-81a2cf58e1ac",
	"00000000-0000-0000-0000-000000000000",
	'getActionOfState',
	'Returns the identifier of the action instance associated with the specified 
element. Will return an invalid identifier if the model isn''t correct for this 
action.',
	'// Start with an invalid id.
select any act from instances of ACT where selected.id != selected.id;
id = act.id;
result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any sub from instances of SUB where selected.name == param.object;
  if (empty sub)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Object, " + param.object + ", not instantiated!" );
  else
    select any sta related by sub->LIF[R347]->SM[R300]->STA[R341] where selected.name == param.state;
    if (empty sta)
      select any sta related by sub->ASR[R354]->SM[R300]->STA[R341] where selected.name == param.state;
      if (empty sta)
        result = creationResult_t::FAILURE;
        LOG::LogFailure( message:"State, " + param.state + ", not instantiated!" );
      end if;
    end if;
    if ( creationResult_t::SUCCESS == result )
      select one ae related by sta->AE[R509];
      select one act related by ae->ACT[R500];
      if (empty act)
        result = creationResult_t::DUPLICATE;
        LOG::LogFailure( message:"Action not instantiated for state, " + param.state + "." );
      else
        id = act.id;
      end if;
    end if;
  end if;
end if;
return id;

',
	"ba5eda7a-def5-0000-0000-000000000005",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("9bfe940a-e0c5-4d4b-9a8c-43765b32aa6a",
	"659d77cb-9830-41e1-810d-81a2cf58e1ac",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("00ac565c-093f-4b57-b539-aea38a931f86",
	"659d77cb-9830-41e1-810d-81a2cf58e1ac",
	'object',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"9bfe940a-e0c5-4d4b-9a8c-43765b32aa6a",
	'The name of the object that has behavior specified by the state model.');
INSERT INTO S_SPARM
	VALUES ("52dc3c37-ec79-408b-9256-c6be5dd84ce2",
	"659d77cb-9830-41e1-810d-81a2cf58e1ac",
	'state',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00ac565c-093f-4b57-b539-aea38a931f86",
	'The name of the state.');
INSERT INTO PE_PE
	VALUES ("659d77cb-9830-41e1-810d-81a2cf58e1ac",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("c904075e-f036-410c-a06a-e850854c5986",
	"00000000-0000-0000-0000-000000000000",
	'addEnumerationValueToOperand',
	'Add an enumeration value to the left or right hand operand of an expression.',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
    if (empty pro)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
    else
      select any equ related by pro->RE[R502]->EQU[R514];
      if (empty equ)
        result = creationResult_t::FAILURE;
        LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
      else
        select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
        if (empty exp)
          result = creationResult_t::FAILURE;
          LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
        else
          select any enud from instances of ENUD where selected.name == param.enumerationName;
          if (empty enud)
            result = creationResult_t::FAILURE;
            LOG::LogFailure( message:"Enumeration, " + param.enumerationName + ", not instantiated!" );
          else
            select any enuv related by enud->ENUV[R420] where selected.name == param.valueName;
            if (empty enuv)
              result = creationResult_t::FAILURE;
              LOG::LogFailure( message:"Enumeration value, " + param.valueName + ", not instantiated for ," + param.enumerationName + "!" );
            else
              select one dus related by enuv->VAL[R629]->DUS[R624];
              select one oprd related by exp->LHO[R616]->OPRD[R615];
              if (not param.leftHand)
                select one oprd related by exp->RHO[R617]->OPRD[R615];
                if (empty oprd)
                  result = creationResult_t::FAILURE;
                  LOG::LogFailure( message:"Right hand operand not instantiated!" );
                end if;
              end if;
              if (not empty oprd)
                relate oprd to dus across R631;
              end if;
            end if;
          end if;
        end if;
      end if;
    end if;
  end if;
end if;
return result;

',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("4cb601b4-9823-4bbe-afa0-95e6579fd758",
	"c904075e-f036-410c-a06a-e850854c5986",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("f388d9c9-8f80-4046-a6d1-e0aa5b7ae325",
	"c904075e-f036-410c-a06a-e850854c5986",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"4cb601b4-9823-4bbe-afa0-95e6579fd758",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("dac7313b-12b4-4b56-8cd3-7f1c7b537104",
	"c904075e-f036-410c-a06a-e850854c5986",
	'processPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"f388d9c9-8f80-4046-a6d1-e0aa5b7ae325",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("1e903f16-3d3a-49f6-a4f0-62b8f38d671d",
	"c904075e-f036-410c-a06a-e850854c5986",
	'expressionPosition',
	"ba5eda7a-def5-0000-0000-000000000002",
	0,
	'',
	"dac7313b-12b4-4b56-8cd3-7f1c7b537104",
	'The ordinal position of the expression in the equation. This needs to be 
maintained by the external editor.
    This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...
    See the description of expression and R622 for further explanation of 
ordering in adding expressions to the equation.');
INSERT INTO S_SPARM
	VALUES ("23e73b82-8792-4c18-896c-8623643c0662",
	"c904075e-f036-410c-a06a-e850854c5986",
	'leftHand',
	"ba5eda7a-def5-0000-0000-000000000001",
	0,
	'',
	"1e903f16-3d3a-49f6-a4f0-62b8f38d671d",
	'Indicator of adding to the left-hand or right-hand operand. A value of true 
means add to the left-hand operand.');
INSERT INTO S_SPARM
	VALUES ("d4a93f49-4df8-40a8-a801-161a95c3680e",
	"c904075e-f036-410c-a06a-e850854c5986",
	'enumerationName',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"23e73b82-8792-4c18-896c-8623643c0662",
	'The name of the enumeration definition.');
INSERT INTO S_SPARM
	VALUES ("310d887d-9a7c-457b-bc33-dd5291231902",
	"c904075e-f036-410c-a06a-e850854c5986",
	'valueName',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"d4a93f49-4df8-40a8-a801-161a95c3680e",
	'The name of the enumeration value.
');
INSERT INTO PE_PE
	VALUES ("c904075e-f036-410c-a06a-e850854c5986",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("1842005a-9c2f-4032-a298-2b24946b7861",
	"00000000-0000-0000-0000-000000000000",
	'addVariableToOperand',
	'Add a transient variable to the left or right hand operand of an expression.

',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
    if (empty pro)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
    else
      select any re related by pro->RE[R502];
      select one equ related by re->EQU[R514];
      if (empty equ)
        result = creationResult_t::FAILURE;
        LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
      else
        select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
        if (empty exp)
          result = creationResult_t::FAILURE;
          LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
        else
          select any type from instances of TYPE where selected.name == param.typeName;
          if (empty type)
            result = creationResult_t::FAILURE;
            LOG::LogFailure( message:"Type, " + param.typeName + ", not instantiated!" );
          else
            select one oprd related by exp->LHO[R616]->OPRD[R615];
            if (not param.leftHand)
              select one oprd related by exp->RHO[R617]->OPRD[R615];
              if (empty oprd)
                result = creationResult_t::FAILURE;
                LOG::LogFailure( message:"Right hand operand not instantiated!" );
              end if;
            end if;
            if (not empty oprd)
              create object instance var of VAR;
              create object instance trd of TRD;
              trd.name = param.name;
              relate trd to var across R626;
              create object instance dus of DUS;
              relate dus to var across R624;
              relate dus to type across R625;
              relate dus to re across R514;
              LOG::LogInfo( message:"Transient variable created with no value and no assigned operand!" );
              relate oprd to dus across R631;
            end if;
          end if;
        end if;
      end if;
    end if;
  end if;
end if;
return result;

',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("f0c578b1-1933-45f4-9e56-86c527921a90",
	"1842005a-9c2f-4032-a298-2b24946b7861",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("10ff9caa-4d05-48bf-8a8e-aa453b648597",
	"1842005a-9c2f-4032-a298-2b24946b7861",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"f0c578b1-1933-45f4-9e56-86c527921a90",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("fe2e3006-6882-47e9-babe-395821ed92d2",
	"1842005a-9c2f-4032-a298-2b24946b7861",
	'processPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"10ff9caa-4d05-48bf-8a8e-aa453b648597",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("49137b99-2d6c-4808-a952-2de8acd66b09",
	"1842005a-9c2f-4032-a298-2b24946b7861",
	'expressionPosition',
	"ba5eda7a-def5-0000-0000-000000000002",
	0,
	'',
	"fe2e3006-6882-47e9-babe-395821ed92d2",
	'The ordinal position of the expression in the equation. This needs to be 
maintained by the external editor.
    This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...
    See the description of expression and R622 for further explanation of 
ordering in adding expressions to the equation.');
INSERT INTO S_SPARM
	VALUES ("a23e51e9-be9f-4421-a7dc-a9eae6603b26",
	"1842005a-9c2f-4032-a298-2b24946b7861",
	'leftHand',
	"ba5eda7a-def5-0000-0000-000000000001",
	0,
	'',
	"49137b99-2d6c-4808-a952-2de8acd66b09",
	'Indicator of adding to the left-hand or right-hand operand. A value of true 
means add to the left-hand operand.');
INSERT INTO S_SPARM
	VALUES ("50e31fdb-d768-4411-98f1-564a08a7e2bc",
	"1842005a-9c2f-4032-a298-2b24946b7861",
	'name',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"a23e51e9-be9f-4421-a7dc-a9eae6603b26",
	'The name of the variable.');
INSERT INTO S_SPARM
	VALUES ("e9098e7a-1af3-4c65-b9b4-31952c0b9c5f",
	"1842005a-9c2f-4032-a298-2b24946b7861",
	'typeName',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"50e31fdb-d768-4411-98f1-564a08a7e2bc",
	'The name of the data type of the variable.');
INSERT INTO PE_PE
	VALUES ("1842005a-9c2f-4032-a298-2b24946b7861",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("5f6c7855-d4a3-453e-a5ff-f6dd3338986e",
	"00000000-0000-0000-0000-000000000000",
	'addConstantToOperand',
	'Add a constant value to the left or right hand operand of an expression.
    As the actual value isn''t that interesting to the metamodel, the parameter, 
name, is used to allow process model construction within the constraints the 
metamodel. The value of name is symbolic representation of the value is akin to 
using defines in C to represent "magic numbers".
',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
    if (empty pro)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
    else
      select any re related by pro->RE[R502];
      select one equ related by re->EQU[R514];
      if (empty equ)
        result = creationResult_t::FAILURE;
        LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
      else
        select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
        if (empty exp)
          result = creationResult_t::FAILURE;
          LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
        else
          select any type from instances of TYPE where selected.name == param.typeName;
          if (empty type)
            result = creationResult_t::FAILURE;
            LOG::LogFailure( message:"Type, " + param.typeName + ", not instantiated!" );
          else
            select one oprd related by exp->LHO[R616]->OPRD[R615];
            if (not param.leftHand)
              select one oprd related by exp->RHO[R617]->OPRD[R615];
              if (empty oprd)
                result = creationResult_t::FAILURE;
                LOG::LogFailure( message:"Right hand operand not instantiated!" );
              end if;
            end if;
            if (not empty oprd)
              create object instance usv of USV;
              usv.value_name = param.name;
              relate usv to type across R636;
              create object instance val of VAL;
              relate usv to val across R629;
              create object instance dus of DUS;
              relate dus to val across R624;
              relate dus to type across R625;
              create object instance re of RE;
              relate dus to re across R514;
              relate oprd to dus across R631;
            end if;
          end if;
        end if;
      end if;
    end if;
  end if;
end if;
return result;
',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("8d057678-8ef5-4c8e-a2cf-fd2e35661317",
	"5f6c7855-d4a3-453e-a5ff-f6dd3338986e",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("6164a795-2e16-49f8-bc55-5724a3ba2aad",
	"5f6c7855-d4a3-453e-a5ff-f6dd3338986e",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"8d057678-8ef5-4c8e-a2cf-fd2e35661317",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("f5448fe3-2c33-417d-8e8d-1187ae1664f7",
	"5f6c7855-d4a3-453e-a5ff-f6dd3338986e",
	'processPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"6164a795-2e16-49f8-bc55-5724a3ba2aad",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("22262fc0-1f69-418e-820c-011f29778a12",
	"5f6c7855-d4a3-453e-a5ff-f6dd3338986e",
	'expressionPosition',
	"ba5eda7a-def5-0000-0000-000000000002",
	0,
	'',
	"f5448fe3-2c33-417d-8e8d-1187ae1664f7",
	'The ordinal position of the expression in the equation. This needs to be 
maintained by the external editor.
    This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...
    See the description of expression and R622 for further explanation of 
ordering in adding expressions to the equation.');
INSERT INTO S_SPARM
	VALUES ("900aa331-d9de-4667-b674-616d4dada408",
	"5f6c7855-d4a3-453e-a5ff-f6dd3338986e",
	'leftHand',
	"ba5eda7a-def5-0000-0000-000000000001",
	0,
	'',
	"22262fc0-1f69-418e-820c-011f29778a12",
	'Indicator of adding to the left-hand or right-hand operand. A value of true 
means add to the left-hand operand.');
INSERT INTO S_SPARM
	VALUES ("1af17183-e2ae-4d57-a66c-6c811976d841",
	"5f6c7855-d4a3-453e-a5ff-f6dd3338986e",
	'name',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"900aa331-d9de-4667-b674-616d4dada408",
	'The external reference name of the constant value.
    As the actual value isn''t that interesting to the metamodel, the external 
reference name is used to allow process model construction within the 
constraints the metamodel. This symbolic representation of the value is akin to 
the use of defines in C to represent "magic numbers".');
INSERT INTO S_SPARM
	VALUES ("47598e09-667a-4958-baca-ec5f0bf045cf",
	"5f6c7855-d4a3-453e-a5ff-f6dd3338986e",
	'typeName',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"1af17183-e2ae-4d57-a66c-6c811976d841",
	'The name of the data type of the constant value.');
INSERT INTO PE_PE
	VALUES ("5f6c7855-d4a3-453e-a5ff-f6dd3338986e",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("b32fbee6-780f-4a8d-80c7-9a9b39f3f22d",
	"00000000-0000-0000-0000-000000000000",
	'addReturnValueToOperand',
	'Add a return value to the left or right operand of an expression. This bridge 
will be called when an accessor is part of an equation. e.g., a = a + sum(b, c)
    If the return value is on the right hand side of an assignment, it can be 
the return from the current process model.
    This call will be used whenever any synchronous accessor (synchronous 
bridge, object method, or attribute action) is added to a process model. ',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
    if (empty pro)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
    else
      select any equ related by pro->RE[R502]->EQU[R514];
      if (empty equ)
        result = creationResult_t::FAILURE;
        LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
      else
        select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
        if (empty exp)
          result = creationResult_t::FAILURE;
          LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
        else
          select any rvl from instances of RVL where selected.access_name == param.name;
          if (empty rvl)
            result = creationResult_t::FAILURE;
            LOG::LogFailure( message:"Return value, " + param.name + ", not instantiated!" );
          else
            select one dus related by rvl->VAL[R629]->DUS[R624];
            select one oprd related by exp->LHO[R616]->OPRD[R615];
            if (empty oprd)
              result = creationResult_t::FAILURE;
              LOG::LogFailure( message:"Left hand operand not instantiated!" );
            else
              if (not param.leftHand)
                select one oprd related by exp->RHO[R617]->OPRD[R615];
                if (empty oprd)
                  result = creationResult_t::FAILURE;
                  LOG::LogFailure( message:"Right hand operand not instantiated!" );
                end if;
              end if;
              if (not empty oprd)
                select one acc related by rvl->SYA[R529]->ACC[R505];
                if ((not param.leftHand) and (act.getAccessorName() == acc.name))
                    relate oprd to dus across R631;
                else
                  relate oprd to dus across R631;
                  instId = acc.instantiate();
                  select any ain from instances of AIN where selected.id == instId;
                  ain.addToProcessModel( actionId:act.id, ordinalPosition:param.processPosition );
                end if;
              end if;
            end if;
          end if;
        end if;
      end if;
    end if;
  end if;
end if;
return result;

',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("98aa50af-7f2a-4de7-a85b-ee3f13931dcf",
	"b32fbee6-780f-4a8d-80c7-9a9b39f3f22d",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("cc591410-bc1e-452f-8bd6-855c61ceee12",
	"b32fbee6-780f-4a8d-80c7-9a9b39f3f22d",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"98aa50af-7f2a-4de7-a85b-ee3f13931dcf",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("65992c73-04ff-4fb3-bede-061fb5f22436",
	"b32fbee6-780f-4a8d-80c7-9a9b39f3f22d",
	'processPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"cc591410-bc1e-452f-8bd6-855c61ceee12",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("1083b9c4-04e4-45e4-9e46-25499ec2a9bb",
	"b32fbee6-780f-4a8d-80c7-9a9b39f3f22d",
	'expressionPosition',
	"ba5eda7a-def5-0000-0000-000000000002",
	0,
	'',
	"65992c73-04ff-4fb3-bede-061fb5f22436",
	'The ordinal position of the expression in the equation. This needs to be 
maintained by the external editor.
    This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...
    See the description of expression and R622 for further explanation of 
ordering in adding expressions to the equation.');
INSERT INTO S_SPARM
	VALUES ("d9e6deb3-cca8-4100-a099-492211ac62a3",
	"b32fbee6-780f-4a8d-80c7-9a9b39f3f22d",
	'leftHand',
	"ba5eda7a-def5-0000-0000-000000000001",
	0,
	'',
	"1083b9c4-04e4-45e4-9e46-25499ec2a9bb",
	'Indicator of adding to the left-hand or right-hand operand. A value of true 
means add to the left-hand operand.');
INSERT INTO S_SPARM
	VALUES ("08916da1-b58c-4b3d-a01f-7d0b4a32ec9d",
	"b32fbee6-780f-4a8d-80c7-9a9b39f3f22d",
	'name',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"d9e6deb3-cca8-4100-a099-492211ac62a3",
	'The fully qualified name of the accessor being called that returns a value.');
INSERT INTO PE_PE
	VALUES ("b32fbee6-780f-4a8d-80c7-9a9b39f3f22d",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("ebb39031-138f-4594-a810-11d5d77d5291",
	"00000000-0000-0000-0000-000000000000",
	'addBridgeAccessorToProcess',
	'Adds an asynchronous bridge call to the process specified in the action 
specified.
    A synchronous bridge call will be added as a return value added to an 
operand.',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    select any pro related by act->PRO[R501] where selected.ordinal_position == param.ordinalPosition;
    if (empty pro)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.ordinalPosition ) + "!");
    else
      select any asb from instances of ASB where selected.name == param.name;
      if (empty asb)
        result = creationResult_t::FAILURE;
        LOG::LogFailure( message:"Bridge, " + param.name + "not instantiated!");
      else
        select one acc related by asb->ASA[R506]->ACC[R505];
        instId = acc.instantiate();
        select any ain from instances of AIN where selected.id == instId;
        ain.addToProcessModel( actionId:act.id, ordinalPosition:param.ordinalPosition );
      end if;
    end if;
  end if;
end if;
return result;

',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("1ccd61e8-2f03-43ef-9b3f-876105f6fbac",
	"ebb39031-138f-4594-a810-11d5d77d5291",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("81a21966-348a-48ad-83da-bd19ea8237a3",
	"ebb39031-138f-4594-a810-11d5d77d5291",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"1ccd61e8-2f03-43ef-9b3f-876105f6fbac",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("b65af0be-c164-45ef-9207-11d9c5a3b6d7",
	"ebb39031-138f-4594-a810-11d5d77d5291",
	'ordinalPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"81a21966-348a-48ad-83da-bd19ea8237a3",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("b12ca481-4a5a-4a21-898b-0d4e4b9d7851",
	"ebb39031-138f-4594-a810-11d5d77d5291",
	'name',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"b65af0be-c164-45ef-9207-11d9c5a3b6d7",
	'The name of the bridge accessor.
');
INSERT INTO PE_PE
	VALUES ("ebb39031-138f-4594-a810-11d5d77d5291",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("b0823148-ce6f-4d36-a85f-306a0d1e22fe",
	"00000000-0000-0000-0000-000000000000",
	'addEventAccessorToProcess',
	'Adds an event accessor to the process specified in the action specified.

',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    select any pro related by act->PRO[R501] where selected.ordinal_position == param.ordinalPosition;
    if (empty pro)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.ordinalPosition ) + "!");
    else
      // TODO: Event instances require an object instance
      select any evt from instances of EVT where (selected.name == param.name) and (selected.object_name == param.object);
      if (empty evt)
        result = creationResult_t::FAILURE;
        LOG::LogFailure( message:"Event, " + param.name + ", not instantiated for object, " + param.object + "!" );
      else
        select one acc related by evt->ASA[R506]->ACC[R505];
        instId = acc.instantiate();
        select any ain from instances of AIN where selected.id == instId;
        ain.addToProcessModel( actionId:act.id, ordinalPosition:param.ordinalPosition );
      end if;
    end if;
  end if;
end if;
return result;

',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("82fcc86a-906f-4db1-874c-2879c0ceff08",
	"b0823148-ce6f-4d36-a85f-306a0d1e22fe",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("f89b6012-128d-4949-95cd-214a04da5fba",
	"b0823148-ce6f-4d36-a85f-306a0d1e22fe",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"82fcc86a-906f-4db1-874c-2879c0ceff08",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("18e82607-1699-419f-9382-3dbc1c75edee",
	"b0823148-ce6f-4d36-a85f-306a0d1e22fe",
	'ordinalPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"f89b6012-128d-4949-95cd-214a04da5fba",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("ac676427-d98e-4e49-a730-f50192a0deda",
	"b0823148-ce6f-4d36-a85f-306a0d1e22fe",
	'name',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"18e82607-1699-419f-9382-3dbc1c75edee",
	'The name of the bridge accessor.
');
INSERT INTO S_SPARM
	VALUES ("d710b6b2-9864-4876-9fbd-d53b2d359b56",
	"b0823148-ce6f-4d36-a85f-306a0d1e22fe",
	'object',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"ac676427-d98e-4e49-a730-f50192a0deda",
	'The object associated with the event.');
INSERT INTO PE_PE
	VALUES ("b0823148-ce6f-4d36-a85f-306a0d1e22fe",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("b1e60b11-40d2-49ab-8236-80e74ba05e76",
	"00000000-0000-0000-0000-000000000000",
	'addRelationshipInstanceToOperand',
	'Creates an instance of the specified relationship and attaches it to the 
operand at the specified position.',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
    if (empty pro)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
    else
      select any equ related by pro->RE[R502]->EQU[R514];
      if (empty equ)
        result = creationResult_t::FAILURE;
        LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
      else
        select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
        if (empty exp)
          result = creationResult_t::FAILURE;
          LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
        else
          select any sub from instances of SUB where selected.name == param.toObject;
          if (empty sub)
            result = creationResult_t::FAILURE;
            LOG::LogFailure( message:"To object, " + param.toObject + ", not instantiated!" );
          else
            select any irl from instances of IRL where (selected.number == param.relationshipNumber) and ((selected.left_object_name == param.toObject) or (selected.right_object_name == param.toObject));
            if (empty irl)
              result = creationResult_t::FAILURE;
              LOG::LogFailure( message:"Relationship, R" + TC::intToString( i: param.relationshipNumber ) + ", not instantiated or not related to object, " + param.toObject + "!" );
            else
              select one oprd related by exp->LHO[R616]->OPRD[R615];
              if (empty oprd)
                result = creationResult_t::FAILURE;
                LOG::LogFailure( message:"Left hand operand not instantiated!" );
              else
                if (not param.leftHand)
                  select one oprd related by exp->RHO[R617]->OPRD[R615];
                  if (empty oprd)
                    result = creationResult_t::FAILURE;
                    LOG::LogFailure( message:"Right hand operand not instantiated!" );
                  end if;
                end if;
                if (not empty oprd)
                  create object instance rin of RIN;
                  relate rin to irl across R638;
                  create object instance val of VAL;
                  relate val to rin across R629;
                  create object instance dus of DUS;
                  relate dus to val across R624;
                  select any rref from instances of RREF;
                  relate rin to rref across R421;
                  select one type related by rref->CORE[R403]->TYPE[R401];
                  relate type to dus across R625;
                  relate oprd to dus across R631;
                end if;
              end if;
            end if;
          end if;
        end if;
      end if;
    end if;
  end if;
end if;
return result;

',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("9468263b-6952-4440-866c-42de5a012fd6",
	"b1e60b11-40d2-49ab-8236-80e74ba05e76",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("966f9dea-ca49-4329-b076-9091fabdf5bf",
	"b1e60b11-40d2-49ab-8236-80e74ba05e76",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"9468263b-6952-4440-866c-42de5a012fd6",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("b3f1bdde-568c-489a-8507-480576a5f268",
	"b1e60b11-40d2-49ab-8236-80e74ba05e76",
	'processPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"966f9dea-ca49-4329-b076-9091fabdf5bf",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("cc935250-4a4a-4abc-803d-b376f64021cb",
	"b1e60b11-40d2-49ab-8236-80e74ba05e76",
	'expressionPosition',
	"ba5eda7a-def5-0000-0000-000000000002",
	0,
	'',
	"b3f1bdde-568c-489a-8507-480576a5f268",
	'The ordinal position of the expression in the equation. This needs to be 
maintained by the external editor.
    This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...
    See the description of expression and R622 for further explanation of 
ordering in adding expressions to the equation.');
INSERT INTO S_SPARM
	VALUES ("fe6c5fb0-5d25-4eaa-a5eb-277535ea8782",
	"b1e60b11-40d2-49ab-8236-80e74ba05e76",
	'relationshipNumber',
	"ba5eda7a-def5-0000-0000-000000000002",
	0,
	'',
	"c60ca878-d35c-4a6a-9a09-9d3727e7d487",
	'');
INSERT INTO S_SPARM
	VALUES ("f0b559a9-aa47-4f99-907c-467b268ff21d",
	"b1e60b11-40d2-49ab-8236-80e74ba05e76",
	'toObject',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"fe6c5fb0-5d25-4eaa-a5eb-277535ea8782",
	'');
INSERT INTO S_SPARM
	VALUES ("c60ca878-d35c-4a6a-9a09-9d3727e7d487",
	"b1e60b11-40d2-49ab-8236-80e74ba05e76",
	'leftHand',
	"ba5eda7a-def5-0000-0000-000000000001",
	0,
	'',
	"cc935250-4a4a-4abc-803d-b376f64021cb",
	'Indicator of adding to the left-hand or right-hand operand. A value of true 
means add to the left-hand operand.');
INSERT INTO PE_PE
	VALUES ("b1e60b11-40d2-49ab-8236-80e74ba05e76",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("a51ae9e8-3174-44fb-8cac-d23846dc3c31",
	"00000000-0000-0000-0000-000000000000",
	'addAccessedParameterToOperand',
	'Add an uninitialized parameter instance to the accessor process model at the 
specified operand. Upon creation of an instance of the accessor and assignment 
of value to the parameter, the uninitialized parameter instance will become 
an initialized parameter instance.',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
    if (empty pro)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
    else
      select any equ related by pro->RE[R502]->EQU[R514];
      if (empty equ)
        result = creationResult_t::FAILURE;
        LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
      else
        select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
        if (empty exp)
          result = creationResult_t::FAILURE;
          LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
        else
          prmAccName = act.getAccessorName();
          select any prm from instances of PRM where (selected.name == param.parameter) and (selected.accessor_name == prmAccName);
          if (empty prm)
            select one sta related by act->AE[R500]->STA[R509];
            if (not empty sta)
              select any evp from instances of EVP where (selected.name == param.parameter) and (selected.state_name == prmAccName);
              if (not empty evp)
                select one prm related by evp->PRM[R542];
              end if;
            end if;
          end if;
          if (empty prm)
            result = creationResult_t::FAILURE;
            LOG::LogFailure( message:"No parameter instance instantiated with the given identifier!");
          else
            select one oprd related by exp->LHO[R616]->OPRD[R615];
            if (empty oprd)
              result = creationResult_t::FAILURE;
              LOG::LogFailure( message:"Left hand operand not instantiated!" );
            else
              if (not param.leftHand)
                select one oprd related by exp->RHO[R617]->OPRD[R615];
                if (empty oprd)
                  result = creationResult_t::FAILURE;
                  LOG::LogFailure( message:"Right hand operand not instantiated!" );
                end if;
              end if;
              if (not empty oprd)
                create object instance prn of PRN;
                relate prn to prm across R645;
                create object instance var of VAR;
                relate var to prn across R626;
                create object instance val of VAL;
                relate val to var across R635;
                // Creating an uninitialized variable as empty set
                // We only need one empty set value for all variables using it.
                select any emp from instances of EMP;
                if (empty emp)
                  create object instance emp of EMP;
                end if;
                relate emp to val across R629;
                create object instance vardus of DUS;
                relate vardus to var across R624;
                create object instance valdus of DUS;
                relate valdus to val across R624;
                select one type related by prm->TYPE[R541];
                relate valdus to type across R625;
                relate vardus to type across R625;
                create object instance varre of RE;
                relate vardus to varre across R514;
                create object instance valre of RE;
                relate valre to valdus across R514;
                relate oprd to vardus across R631;
              end if;
            end if;
          end if;
        end if;
      end if;
    end if;
  end if;
end if;
return result;

',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("c27ef885-0cff-40bc-998b-24dbe005d93c",
	"a51ae9e8-3174-44fb-8cac-d23846dc3c31",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("303cba16-3aa7-4f91-883a-dbc61f58fcf4",
	"a51ae9e8-3174-44fb-8cac-d23846dc3c31",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"c27ef885-0cff-40bc-998b-24dbe005d93c",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("8401384a-ecfd-486a-91c4-edb96aadee20",
	"a51ae9e8-3174-44fb-8cac-d23846dc3c31",
	'processPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"303cba16-3aa7-4f91-883a-dbc61f58fcf4",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("4945d9b7-055a-40e6-bfc6-ebf100859a79",
	"a51ae9e8-3174-44fb-8cac-d23846dc3c31",
	'expressionPosition',
	"ba5eda7a-def5-0000-0000-000000000002",
	0,
	'',
	"8401384a-ecfd-486a-91c4-edb96aadee20",
	'The ordinal position of the expression in the equation. This needs to be 
maintained by the external editor.
    This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...
    See the description of expression and R622 for further explanation of 
ordering in adding expressions to the equation.');
INSERT INTO S_SPARM
	VALUES ("bb1efb06-901d-4b8e-a47c-57796fef7017",
	"a51ae9e8-3174-44fb-8cac-d23846dc3c31",
	'leftHand',
	"ba5eda7a-def5-0000-0000-000000000001",
	0,
	'',
	"4945d9b7-055a-40e6-bfc6-ebf100859a79",
	'Indicator of adding to the left-hand or right-hand operand. A value of true 
means add to the left-hand operand.');
INSERT INTO S_SPARM
	VALUES ("a197a54e-02e5-4278-9403-0b712a9880f0",
	"a51ae9e8-3174-44fb-8cac-d23846dc3c31",
	'parameter',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"bb1efb06-901d-4b8e-a47c-57796fef7017",
	'The unique identifier for the parameter created for this accessor.
    The functionality to create the instances resides in the Architecture 
Domain. These model verification bridges assume the architecture is handling 
these concepts correctly.');
INSERT INTO PE_PE
	VALUES ("a51ae9e8-3174-44fb-8cac-d23846dc3c31",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("a6fba767-0183-409a-8bb3-d30b988574ea",
	"00000000-0000-0000-0000-000000000000",
	'addPerspectiveToOperand',
	'Add a perspective to the specified relationship instance at the specified 
operand position.',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
    if (empty pro)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
    else
      select any equ related by pro->RE[R502]->EQU[R514];
      if (empty equ)
        result = creationResult_t::FAILURE;
        LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
      else
        select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
        if (empty exp)
          result = creationResult_t::FAILURE;
          LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
        else
          select one oprd related by exp->RHO[R617]->OPRD[R615];
          if (param.leftHand)
            select one oprd related by exp->LHO[R616]->OPRD[R615];
          end if;
          if (empty oprd)
            result = creationResult_t::FAILURE;
            LOG::LogFailure( message:"No operand for expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
          else
            select one rin related by oprd->DUS[R631]->VAL[R624]->RIN[R629];
            if (empty rin)
              result = creationResult_t::FAILURE;
              LOG::LogFailure( message:"No relationship instance at the operand for expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
            else
              select one psp related by rin->PSP[R216];
              if (not empty psp)
                result = creationResult_t::DUPLICATE;
                LOG::LogFailure( message:"Relationship instance already has perspective, " + psp.phrase + "!" );
              else
                create object instance trv of TRV;
                select one psp related by rin->IRL[R638]->SYR[R201]->SYP[R206]->PSP[R204];
                if (empty psp)
                  select one psp related by rin->IRL[R638]->BIN[R201]->ACP[R207]->ASP[R205]->PSP[R204];
                  if (empty psp)
                    select one psp related by rin->IRL[R638]->BIN[R201]->PSS[R208]->ASP[R205]->PSP[R204];
                  end if;
                end if;
                relate psp to rin across R216 using trv;
                create object instance re of RE;
                relate re to psp across R514;
                create object instance ela of ELA;
                relate re to pro across R502 using ela;
              end if;
            end if;
          end if;
        end if;
      end if;
    end if;
  end if;
end if;
return result;

',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("53ae9e97-7fe5-4e09-93b8-088052ce0519",
	"a6fba767-0183-409a-8bb3-d30b988574ea",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("bf99f813-65b9-425c-9a54-2bd362378bd1",
	"a6fba767-0183-409a-8bb3-d30b988574ea",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"53ae9e97-7fe5-4e09-93b8-088052ce0519",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("6f21ef74-1bcf-4f5f-bbd6-359410900352",
	"a6fba767-0183-409a-8bb3-d30b988574ea",
	'processPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"bf99f813-65b9-425c-9a54-2bd362378bd1",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("f48cb45c-3c67-45ad-9258-ad5b70e72ac8",
	"a6fba767-0183-409a-8bb3-d30b988574ea",
	'expressionPosition',
	"ba5eda7a-def5-0000-0000-000000000002",
	0,
	'',
	"6f21ef74-1bcf-4f5f-bbd6-359410900352",
	'The ordinal position of the expression in the equation. This needs to be 
maintained by the external editor.
    This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...
    See the description of expression and R622 for further explanation of 
ordering in adding expressions to the equation.');
INSERT INTO S_SPARM
	VALUES ("511a3cea-a7b2-4733-b5ae-ab898d818865",
	"a6fba767-0183-409a-8bb3-d30b988574ea",
	'leftHand',
	"ba5eda7a-def5-0000-0000-000000000001",
	0,
	'',
	"f48cb45c-3c67-45ad-9258-ad5b70e72ac8",
	'Indicator of adding to the left-hand or right-hand operand. A value of true 
means add to the left-hand operand.');
INSERT INTO S_SPARM
	VALUES ("0146a2a0-b5a9-4740-b31a-487e4e85995b",
	"a6fba767-0183-409a-8bb3-d30b988574ea",
	'perspective',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"511a3cea-a7b2-4733-b5ae-ab898d818865",
	'The verb phrase of the perspective to add.');
INSERT INTO PE_PE
	VALUES ("a6fba767-0183-409a-8bb3-d30b988574ea",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("a7ee2e2c-b2e7-48cc-a20d-6ece2558acb0",
	"00000000-0000-0000-0000-000000000000",
	'addValueToParameter',
	'Assigns the named value, or the value help by a named variable, to the named 
parameter at the given position in a process model.',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
    if (empty pro)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
    else
      select any prn related by pro->RE[R502]->DUS[R514]->VAR[R624]->PRN[R626] where selected.parameter_name == param.parameter;
      if (empty prn)
        result  = creationResult_t::FAILURE;
        LOG::LogFailure( message:"No parameter named, " + param.parameter + ", in process!" );
      else
        select any equ related by pro->RE[R502]->EQU[R514];
        if (not empty equ)
          // Accessor is being used in an equation, so make sure the upi is correct upi.
          select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
          if (empty exp)
            result = creationResult_t::FAILURE;
            LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
          else
            select one rvl related by exp->RHO[R617]->OPRD[R615]->DUS[R631]->VAL[R624]->RVL[R629];
            if (param.leftHand)
              select one rvl related by exp->LHO[R616]->OPRD[R615]->DUS[R631]->VAL[R624]->RVL[R629];
            end if;
            if (empty rvl)
              result  = creationResult_t::FAILURE;
              LOG::LogFailure( message:"No accessor at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
            else
              select any prn related by rvl->SYA[R529]->ACC[R505]->AIN[R640]->PRN[R647] where selected.parameter_name == param.parameter;
              if (empty prn)
                result  = creationResult_t::FAILURE;
                LOG::LogFailure( message:"No parameter named, " + param.parameter + ", at position, " + TC::realToString( r: param.expressionPosition ) + "!" );
              end if;
            end if;
          end if;
        end if;
      end if;
      if ( creationResult_t::SUCCESS == result )
        // Grab the empty set value
        select one val related by prn->VAR[R626]->VAL[R635];
        oldval = val;
        // Find named value or variable
        select many duss related by pro->RE[R502]->DUS[R514];
        for each dus in duss
          select one usv related by dus->VAL[R624]->USV[R629] where selected.value_name == param.name;
          if (empty usv)
            select one trd related by dus->VAR[R624]->TRD[R626] where selected.name == param.name;
            if (empty trd)
              select one atn related by dus->VAR[R624]->ATN[R626] where selected.attribute_name == param.name;
              if (empty atn)
                select one prn related by dus->VAR[R624]->PRN[R626] where selected.parameter_name == param.name;
                if (not empty prn)
                  select one val related by prn->VAR[R626]->VAL[R635];
                  break;
                end if;
              else
                select one val related by atn->VAR[R626]->VAL[R635];
                break;
              end if;
            else
              select one val related by trd->VAR[R626]->VAL[R635];
              break;
            end if;
          else
            select one val related by usv->VAL[R629];
          end if;
        end for;
        if (oldval == val)
          result  = creationResult_t::FAILURE;
          LOG::LogFailure( message:"No value or variable named, " + param.name + ", in process!" );
        else
          select one var related by prn->VAR[R626];
          unrelate oldval from var across R635;
          relate var to val across R635;
        end if; 
      end if; 
    end if;
  end if;
end if;
return result;
',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("ca8c7e4a-8800-488e-8dbc-bfb43cbc9dc8",
	"a7ee2e2c-b2e7-48cc-a20d-6ece2558acb0",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("2956737d-d72b-409a-837a-9ba1d505ccea",
	"a7ee2e2c-b2e7-48cc-a20d-6ece2558acb0",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"ca8c7e4a-8800-488e-8dbc-bfb43cbc9dc8",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("273d43cb-3a20-46bb-b49a-644ec36f577f",
	"a7ee2e2c-b2e7-48cc-a20d-6ece2558acb0",
	'processPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"2956737d-d72b-409a-837a-9ba1d505ccea",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("67605a3d-ba19-497c-b32a-65c409479304",
	"a7ee2e2c-b2e7-48cc-a20d-6ece2558acb0",
	'expressionPosition',
	"ba5eda7a-def5-0000-0000-000000000002",
	0,
	'',
	"273d43cb-3a20-46bb-b49a-644ec36f577f",
	'The ordinal position of the expression in the equation. This needs to be 
maintained by the external editor.
    This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...
    See the description of expression and R622 for further explanation of 
ordering in adding expressions to the equation.');
INSERT INTO S_SPARM
	VALUES ("0efdab4a-2da7-4b29-a8ec-931d3d1b078c",
	"a7ee2e2c-b2e7-48cc-a20d-6ece2558acb0",
	'leftHand',
	"ba5eda7a-def5-0000-0000-000000000001",
	0,
	'',
	"67605a3d-ba19-497c-b32a-65c409479304",
	'Indicator of adding to the left-hand or right-hand operand. A value of true 
means add to the left-hand operand.');
INSERT INTO S_SPARM
	VALUES ("3a977c9b-7fc5-4731-97e1-abf883636a89",
	"a7ee2e2c-b2e7-48cc-a20d-6ece2558acb0",
	'parameter',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"0efdab4a-2da7-4b29-a8ec-931d3d1b078c",
	'The name of the parameter.');
INSERT INTO S_SPARM
	VALUES ("f95b32d2-3972-406f-bfc3-b63202136915",
	"a7ee2e2c-b2e7-48cc-a20d-6ece2558acb0",
	'name',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"3a977c9b-7fc5-4731-97e1-abf883636a89",
	'The reference name of the value. The value can be specified as a variable or a 
value.');
INSERT INTO PE_PE
	VALUES ("a7ee2e2c-b2e7-48cc-a20d-6ece2558acb0",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("36c377d2-c163-413c-949b-98ac52077eb8",
	"00000000-0000-0000-0000-000000000000",
	'addKeywordToOperand',
	'Adds a the specified keyword value to the process model at the specified 
statement position.',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
    if (empty pro)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
    else
      select any equ related by pro->RE[R502]->EQU[R514];
      if (empty equ)
        result = creationResult_t::FAILURE;
        LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
      else
        select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
        if (empty exp)
          result = creationResult_t::FAILURE;
          LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
        else
          select one oprd related by exp->LHO[R616]->OPRD[R615];
          if (not param.leftHand)
            select one oprd related by exp->RHO[R617]->OPRD[R615];
            if (empty oprd)
              result = creationResult_t::FAILURE;
              LOG::LogFailure( message:"Right hand operand not instantiated!" );
            end if;
          end if;
          if (empty oprd)
            result = creationResult_t::FAILURE;
            LOG::LogFailure( message:"Left hand operand not instantiated!" );
          else
            select any keyi from instances of KEYI where selected.keyword == param.name;
            if (empty keyi)
              select any key from instances of KEY;
              create object instance keyi of KEYI;
              keyi.keyword = param.name;
              relate keyi to key across R423;
              create object instance val of VAL;
              relate keyi to val across R629;
              create object instance dus of DUS;
              relate val to dus across R624;
              select one type related by key->CORE[R403]->TYPE[R401];
              relate type to dus across R625;
              relate oprd to dus across R631;
            else
              select one dus related by keyi->VAL[R629]->DUS[R624];
              relate oprd to dus across R631;
            end if;
          end if;
        end if;
      end if;
    end if;
  end if;
end if;
return result;
',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("e422eb47-f387-4a4b-b253-8a9fbf85a12f",
	"36c377d2-c163-413c-949b-98ac52077eb8",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("78bb5bec-6bde-464d-ae05-d74beae85037",
	"36c377d2-c163-413c-949b-98ac52077eb8",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"e422eb47-f387-4a4b-b253-8a9fbf85a12f",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("2516b5d5-1df3-41e7-affc-3bcca83bdbd9",
	"36c377d2-c163-413c-949b-98ac52077eb8",
	'processPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"78bb5bec-6bde-464d-ae05-d74beae85037",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("b3298e10-293e-46e0-abb9-75e647f07c78",
	"36c377d2-c163-413c-949b-98ac52077eb8",
	'name',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"2516b5d5-1df3-41e7-affc-3bcca83bdbd9",
	'The keyword value to place.');
INSERT INTO S_SPARM
	VALUES ("d720650d-e558-4c67-8f4a-b1c34fad0ccb",
	"36c377d2-c163-413c-949b-98ac52077eb8",
	'expressionPosition',
	"ba5eda7a-def5-0000-0000-000000000002",
	0,
	'',
	"b3298e10-293e-46e0-abb9-75e647f07c78",
	'The ordinal position of the expression in the equation. This needs to be 
maintained by the external editor.
    This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...
    See the description of expression and R622 for further explanation of 
ordering in adding expressions to the equation.');
INSERT INTO S_SPARM
	VALUES ("2e048406-3188-4416-bce7-3dc5f0d19391",
	"36c377d2-c163-413c-949b-98ac52077eb8",
	'leftHand',
	"ba5eda7a-def5-0000-0000-000000000001",
	0,
	'',
	"d720650d-e558-4c67-8f4a-b1c34fad0ccb",
	'Indicator of adding to the left-hand or right-hand operand. A value of true 
means add to the left-hand operand.');
INSERT INTO PE_PE
	VALUES ("36c377d2-c163-413c-949b-98ac52077eb8",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO S_SYNC
	VALUES ("0989b53a-2309-41a5-af5d-1a7449a595e7",
	"00000000-0000-0000-0000-000000000000",
	'addTypedOperatorToExpression',
	'',
	'result = creationResult_t::SUCCESS;
select any mdom from instances of MDOM where selected.name == param.domain;
if (empty mdom)
  result = creationResult_t::FAILURE;
  LOG::LogFailure( message:"Domain, " + param.domain + ", not instantiated!" );
else
  select any act from instances of ACT where selected.id == param.actionId;
  if (empty act)
    result = creationResult_t::FAILURE;
    LOG::LogFailure( message:"Action not instantiated!" );
  else
    select any pro related by act->PRO[R501] where selected.ordinal_position == param.processPosition;
    if (empty pro)
      result = creationResult_t::FAILURE;
      LOG::LogFailure( message:"No process at position, " + TC::realToString( r: param.processPosition ) + "!");
    else
      select any equ related by pro->RE[R502]->EQU[R514];
      if (empty equ)
        result = creationResult_t::FAILURE;
        LOG::LogFailure( message:"No equation at process at position, " + TC::realToString( r: param.processPosition ) + "!");
      else
        select any exp related by equ->EXP[R622] where selected.ordinal_position == param.expressionPosition;
        if (empty exp)
          result = creationResult_t::FAILURE;
          LOG::LogFailure( message:"No expression at equation at position, " + TC::realToString( r: param.expressionPosition ) + "!");
        else
          select one oprd related by exp->RHO[R617]->OPRD[R615];
          if (empty oprd)
            result = creationResult_t::FAILURE;
            LOG::LogFailure( message:"No operand has been added to the expression!"); 
          else
            select any tyop from instances of TYOP where (selected.operation_name == param.operator) and (selected.type_name == param.type) and (selected.result_type_name == param.resultType);
            if (empty tyop)
              result = creationResult_t::FAILURE;
              LOG::LogFailure( message:"No typed operator, " + param.operator + ", with type, " + param.type + ", and result type, " + param.resultType + ", instantiated!");
            else
              relate tyop to exp across R632;
              create object instance out of OUT;
              relate out to exp across R611;
              relate out to tyop across R634;
              relate out to oprd across R618;
            end if;
          end if;
        end if;
      end if;
    end if;
  end if;
end if;
return result;
',
	"709da393-5976-4a6f-9ea6-b5c91ab9f7a4",
	1,
	'',
	0);
INSERT INTO S_SPARM
	VALUES ("dccf483c-1c1a-4521-85f6-55f4ce3bb423",
	"0989b53a-2309-41a5-af5d-1a7449a595e7",
	'domain',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"00000000-0000-0000-0000-000000000000",
	'The modeled domain name.
');
INSERT INTO S_SPARM
	VALUES ("bcdaeea1-4c7e-4e2f-b40b-ef9a10443cbb",
	"0989b53a-2309-41a5-af5d-1a7449a595e7",
	'actionId',
	"ba5eda7a-def5-0000-0000-000000000005",
	0,
	'',
	"dccf483c-1c1a-4521-85f6-55f4ce3bb423",
	'The identifier for the Action instance. It should have been obtained from a 
prior call to getActionTo<Active Element name>.
');
INSERT INTO S_SPARM
	VALUES ("6a95b4a3-5df2-465e-8443-1aa002f272ff",
	"0989b53a-2309-41a5-af5d-1a7449a595e7",
	'processPosition',
	"ba5eda7a-def5-0000-0000-000000000003",
	0,
	'',
	"bcdaeea1-4c7e-4e2f-b40b-ef9a10443cbb",
	'The ordinal position of the process in the action. This needs to be maintained 
by the external editor.
This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...');
INSERT INTO S_SPARM
	VALUES ("883f0797-9e1b-48f9-bba8-94295e192de0",
	"0989b53a-2309-41a5-af5d-1a7449a595e7",
	'expressionPosition',
	"ba5eda7a-def5-0000-0000-000000000002",
	0,
	'',
	"6a95b4a3-5df2-465e-8443-1aa002f272ff",
	'The ordinal position of the expression in the equation. This needs to be 
maintained by the external editor.
    This is specified as a real in BridgePoint to allow for a nesting scheme.
e.g., 1, 2, 3, 3.1, 4, 4.1, 4.1.1, ...
    See the description of expression and R622 for further explanation of 
ordering in adding expressions to the equation.');
INSERT INTO S_SPARM
	VALUES ("94f6d4c7-6c9f-4ba7-8d43-c8d9025fbd08",
	"0989b53a-2309-41a5-af5d-1a7449a595e7",
	'operator',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"883f0797-9e1b-48f9-bba8-94295e192de0",
	'');
INSERT INTO S_SPARM
	VALUES ("c7bea7f7-0e8d-4f8d-8fc7-5928c334fe74",
	"0989b53a-2309-41a5-af5d-1a7449a595e7",
	'type',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"94f6d4c7-6c9f-4ba7-8d43-c8d9025fbd08",
	'');
INSERT INTO S_SPARM
	VALUES ("4cc995f2-47a0-4d16-a64b-d00c9779931e",
	"0989b53a-2309-41a5-af5d-1a7449a595e7",
	'resultType',
	"ba5eda7a-def5-0000-0000-000000000004",
	0,
	'',
	"c7bea7f7-0e8d-4f8d-8fc7-5928c334fe74",
	'');
INSERT INTO PE_PE
	VALUES ("0989b53a-2309-41a5-af5d-1a7449a595e7",
	1,
	"1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	"00000000-0000-0000-0000-000000000000",
	1);
INSERT INTO PE_PE
	VALUES ("1ede4858-ce7f-4fe8-af7f-a27ebf1c00ab",
	1,
	"9ddf81e7-a28d-4e3c-b59b-ce104ef0f540",
	"00000000-0000-0000-0000-000000000000",
	7);
INSERT INTO EP_PKG_PROXY
	VALUES ("9ddf81e7-a28d-4e3c-b59b-ce104ef0f540",
	"00000000-0000-0000-0000-000000000000",
	"c8b88000-dddc-4206-8410-2f69b8f86b67",
	'Incoming Bridges',
	'Bridges into the metamodel domain.',
	0,
	'../Incoming Bridges.xtuml');
INSERT INTO S_SYS_PROXY
	VALUES ("c8b88000-dddc-4206-8410-2f69b8f86b67",
	'shlaer-mellor-metamodel',
	1,
	'../../../../shlaer-mellor-metamodel.xtuml');
